home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / idlelib / rpc.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-29  |  22KB  |  688 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. """RPC Implemention, originally written for the Python Idle IDE
  5.  
  6. For security reasons, GvR requested that Idle's Python execution server process
  7. connect to the Idle process, which listens for the connection.  Since Idle has
  8. has only one client per server, this was not a limitation.
  9.  
  10.    +---------------------------------+ +-------------+
  11.    | SocketServer.BaseRequestHandler | | SocketIO    |
  12.    +---------------------------------+ +-------------+
  13.                    ^                   | register()  |
  14.                    |                   | unregister()|
  15.                    |                   +-------------+
  16.                    |                      ^  ^
  17.                    |                      |  |
  18.                    | + -------------------+  |
  19.                    | |                       |
  20.    +-------------------------+        +-----------------+
  21.    | RPCHandler              |        | RPCClient       |
  22.    | [attribute of RPCServer]|        |                 |
  23.    +-------------------------+        +-----------------+
  24.  
  25. The RPCServer handler class is expected to provide register/unregister methods.
  26. RPCHandler inherits the mix-in class SocketIO, which provides these methods.
  27.  
  28. See the Idle run.main() docstring for further information on how this was
  29. accomplished in Idle.
  30.  
  31. """
  32. import sys
  33. import os
  34. import socket
  35. import select
  36. import SocketServer
  37. import struct
  38. import cPickle as pickle
  39. import threading
  40. import Queue
  41. import traceback
  42. import copy_reg
  43. import types
  44. import marshal
  45.  
  46. def unpickle_code(ms):
  47.     co = marshal.loads(ms)
  48.     if not isinstance(co, types.CodeType):
  49.         raise AssertionError
  50.     return co
  51.  
  52.  
  53. def pickle_code(co):
  54.     if not isinstance(co, types.CodeType):
  55.         raise AssertionError
  56.     ms = marshal.dumps(co)
  57.     return (unpickle_code, (ms,))
  58.  
  59. copy_reg.pickle(types.CodeType, pickle_code, unpickle_code)
  60. BUFSIZE = 8 * 1024
  61. LOCALHOST = '127.0.0.1'
  62.  
  63. class RPCServer(SocketServer.TCPServer):
  64.     
  65.     def __init__(self, addr, handlerclass = None):
  66.         if handlerclass is None:
  67.             handlerclass = RPCHandler
  68.         
  69.         SocketServer.TCPServer.__init__(self, addr, handlerclass)
  70.  
  71.     
  72.     def server_bind(self):
  73.         '''Override TCPServer method, no bind() phase for connecting entity'''
  74.         pass
  75.  
  76.     
  77.     def server_activate(self):
  78.         '''Override TCPServer method, connect() instead of listen()
  79.  
  80.         Due to the reversed connection, self.server_address is actually the
  81.         address of the Idle Client to which we are connecting.
  82.  
  83.         '''
  84.         self.socket.connect(self.server_address)
  85.  
  86.     
  87.     def get_request(self):
  88.         '''Override TCPServer method, return already connected socket'''
  89.         return (self.socket, self.server_address)
  90.  
  91.     
  92.     def handle_error(self, request, client_address):
  93.         '''Override TCPServer method
  94.  
  95.         Error message goes to __stderr__.  No error message if exiting
  96.         normally or socket raised EOF.  Other exceptions not handled in
  97.         server code will cause os._exit.
  98.  
  99.         '''
  100.         
  101.         try:
  102.             raise 
  103.         except SystemExit:
  104.             raise 
  105.         except:
  106.             erf = sys.__stderr__
  107.             print >>erf, '\n' + '-' * 40
  108.             print >>erf, 'Unhandled server exception!'
  109.             print >>erf, 'Thread: %s' % threading.currentThread().getName()
  110.             print >>erf, 'Client Address: ', client_address
  111.             print >>erf, 'Request: ', repr(request)
  112.             traceback.print_exc(file = erf)
  113.             print >>erf, '\n*** Unrecoverable, server exiting!'
  114.             print >>erf, '-' * 40
  115.             os._exit(0)
  116.  
  117.  
  118.  
  119. objecttable = { }
  120. request_queue = Queue.Queue(0)
  121. response_queue = Queue.Queue(0)
  122.  
  123. class SocketIO(object):
  124.     nextseq = 0
  125.     
  126.     def __init__(self, sock, objtable = None, debugging = None):
  127.         self.sockthread = threading.currentThread()
  128.         if debugging is not None:
  129.             self.debugging = debugging
  130.         
  131.         self.sock = sock
  132.         if objtable is None:
  133.             objtable = objecttable
  134.         
  135.         self.objtable = objtable
  136.         self.responses = { }
  137.         self.cvars = { }
  138.  
  139.     
  140.     def close(self):
  141.         sock = self.sock
  142.         self.sock = None
  143.         if sock is not None:
  144.             sock.close()
  145.         
  146.  
  147.     
  148.     def exithook(self):
  149.         '''override for specific exit action'''
  150.         os._exit()
  151.  
  152.     
  153.     def debug(self, *args):
  154.         if not self.debugging:
  155.             return None
  156.         
  157.         s = self.location + ' ' + str(threading.currentThread().getName())
  158.         for a in args:
  159.             s = s + ' ' + str(a)
  160.         
  161.         print >>sys.__stderr__, s
  162.  
  163.     
  164.     def register(self, oid, object):
  165.         self.objtable[oid] = object
  166.  
  167.     
  168.     def unregister(self, oid):
  169.         
  170.         try:
  171.             del self.objtable[oid]
  172.         except KeyError:
  173.             pass
  174.  
  175.  
  176.     
  177.     def localcall(self, seq, request):
  178.         self.debug('localcall:', request)
  179.         
  180.         try:
  181.             (oid, methodname, args, kwargs) = (how,)
  182.         except TypeError:
  183.             return ('ERROR', 'Bad request format')
  184.  
  185.         if not self.objtable.has_key(oid):
  186.             return ('ERROR', 'Unknown object id: %r' % (oid,))
  187.         
  188.         obj = self.objtable[oid]
  189.         if methodname == '__methods__':
  190.             methods = { }
  191.             _getmethods(obj, methods)
  192.             return ('OK', methods)
  193.         
  194.         if methodname == '__attributes__':
  195.             attributes = { }
  196.             _getattributes(obj, attributes)
  197.             return ('OK', attributes)
  198.         
  199.         if not hasattr(obj, methodname):
  200.             return ('ERROR', 'Unsupported method name: %r' % (methodname,))
  201.         
  202.         method = getattr(obj, methodname)
  203.         
  204.         try:
  205.             if how == 'CALL':
  206.                 ret = method(*args, **kwargs)
  207.                 if isinstance(ret, RemoteObject):
  208.                     ret = remoteref(ret)
  209.                 
  210.                 return ('OK', ret)
  211.             elif how == 'QUEUE':
  212.                 request_queue.put((seq, (method, args, kwargs)))
  213.                 return ('QUEUED', None)
  214.             else:
  215.                 return ('ERROR', 'Unsupported message type: %s' % how)
  216.         except SystemExit:
  217.             raise 
  218.         except socket.error:
  219.             raise 
  220.         except:
  221.             msg = '*** Internal Error: rpc.py:SocketIO.localcall()\n\n Object: %s \n Method: %s \n Args: %s\n'
  222.             print >>sys.__stderr__, msg % (oid, method, args)
  223.             traceback.print_exc(file = sys.__stderr__)
  224.             return ('EXCEPTION', None)
  225.  
  226.  
  227.     
  228.     def remotecall(self, oid, methodname, args, kwargs):
  229.         self.debug('remotecall:asynccall: ', oid, methodname)
  230.         seq = self.asynccall(oid, methodname, args, kwargs)
  231.         return self.asyncreturn(seq)
  232.  
  233.     
  234.     def remotequeue(self, oid, methodname, args, kwargs):
  235.         self.debug('remotequeue:asyncqueue: ', oid, methodname)
  236.         seq = self.asyncqueue(oid, methodname, args, kwargs)
  237.         return self.asyncreturn(seq)
  238.  
  239.     
  240.     def asynccall(self, oid, methodname, args, kwargs):
  241.         request = ('CALL', (oid, methodname, args, kwargs))
  242.         seq = self.newseq()
  243.         if threading.currentThread() != self.sockthread:
  244.             cvar = threading.Condition()
  245.             self.cvars[seq] = cvar
  246.         
  247.         self.debug('asynccall:%d:' % seq, oid, methodname, args, kwargs)
  248.         self.putmessage((seq, request))
  249.         return seq
  250.  
  251.     
  252.     def asyncqueue(self, oid, methodname, args, kwargs):
  253.         request = ('QUEUE', (oid, methodname, args, kwargs))
  254.         seq = self.newseq()
  255.         if threading.currentThread() != self.sockthread:
  256.             cvar = threading.Condition()
  257.             self.cvars[seq] = cvar
  258.         
  259.         self.debug('asyncqueue:%d:' % seq, oid, methodname, args, kwargs)
  260.         self.putmessage((seq, request))
  261.         return seq
  262.  
  263.     
  264.     def asyncreturn(self, seq):
  265.         self.debug('asyncreturn:%d:call getresponse(): ' % seq)
  266.         response = self.getresponse(seq, wait = 0.05)
  267.         self.debug('asyncreturn:%d:response: ' % seq, response)
  268.         return self.decoderesponse(response)
  269.  
  270.     
  271.     def decoderesponse(self, response):
  272.         (how, what) = response
  273.         if how == 'OK':
  274.             return what
  275.         
  276.         if how == 'QUEUED':
  277.             return None
  278.         
  279.         if how == 'EXCEPTION':
  280.             self.debug('decoderesponse: EXCEPTION')
  281.             return None
  282.         
  283.         if how == 'EOF':
  284.             self.debug('decoderesponse: EOF')
  285.             self.decode_interrupthook()
  286.             return None
  287.         
  288.         if how == 'ERROR':
  289.             self.debug('decoderesponse: Internal ERROR:', what)
  290.             raise RuntimeError, what
  291.         
  292.         raise SystemError, (how, what)
  293.  
  294.     
  295.     def decode_interrupthook(self):
  296.         ''''''
  297.         raise EOFError
  298.  
  299.     
  300.     def mainloop(self):
  301.         '''Listen on socket until I/O not ready or EOF
  302.  
  303.         pollresponse() will loop looking for seq number None, which
  304.         never comes, and exit on EOFError.
  305.  
  306.         '''
  307.         
  308.         try:
  309.             self.getresponse(myseq = None, wait = 0.05)
  310.         except EOFError:
  311.             self.debug('mainloop:return')
  312.             return None
  313.  
  314.  
  315.     
  316.     def getresponse(self, myseq, wait):
  317.         response = self._getresponse(myseq, wait)
  318.         if response is not None:
  319.             (how, what) = response
  320.             if how == 'OK':
  321.                 response = (how, self._proxify(what))
  322.             
  323.         
  324.         return response
  325.  
  326.     
  327.     def _proxify(self, obj):
  328.         if isinstance(obj, RemoteProxy):
  329.             return RPCProxy(self, obj.oid)
  330.         
  331.         if isinstance(obj, types.ListType):
  332.             return map(self._proxify, obj)
  333.         
  334.         return obj
  335.  
  336.     
  337.     def _getresponse(self, myseq, wait):
  338.         self.debug('_getresponse:myseq:', myseq)
  339.         if threading.currentThread() is self.sockthread:
  340.             while None:
  341.                 response = self.pollresponse(myseq, wait)
  342.                 if response is not None:
  343.                     return response
  344.                     continue
  345.                 continue
  346.         threading.currentThread() is self.sockthread
  347.         cvar = self.cvars[myseq]
  348.         cvar.acquire()
  349.         while not self.responses.has_key(myseq):
  350.             cvar.wait()
  351.         response = self.responses[myseq]
  352.         self.debug('_getresponse:%s: thread woke up: response: %s' % (myseq, response))
  353.         del self.responses[myseq]
  354.         del self.cvars[myseq]
  355.         cvar.release()
  356.         return response
  357.  
  358.     
  359.     def newseq(self):
  360.         self.nextseq = seq = self.nextseq + 2
  361.         return seq
  362.  
  363.     
  364.     def putmessage(self, message):
  365.         self.debug('putmessage:%d:' % message[0])
  366.         
  367.         try:
  368.             s = pickle.dumps(message)
  369.         except pickle.PicklingError:
  370.             print >>sys.__stderr__, 'Cannot pickle:', repr(message)
  371.             raise 
  372.  
  373.         s = struct.pack('<i', len(s)) + s
  374.         while len(s) > 0:
  375.             
  376.             try:
  377.                 (r, w, x) = select.select([], [
  378.                     self.sock], [])
  379.                 n = self.sock.send(s[:BUFSIZE])
  380.             except (AttributeError, TypeError):
  381.                 raise IOError, 'socket no longer exists'
  382.                 continue
  383.                 except socket.error:
  384.                     raise 
  385.                     continue
  386.                 else:
  387.                     s = s[n:]
  388.                 None<EXCEPTION MATCH>socket.error
  389.             return None
  390.  
  391.  
  392.     buffer = ''
  393.     bufneed = 4
  394.     bufstate = 0
  395.     
  396.     def pollpacket(self, wait):
  397.         self._stage0()
  398.         if len(self.buffer) < self.bufneed:
  399.             (r, w, x) = select.select([
  400.                 self.sock.fileno()], [], [], wait)
  401.             if len(r) == 0:
  402.                 return None
  403.             
  404.             
  405.             try:
  406.                 s = self.sock.recv(BUFSIZE)
  407.             except socket.error:
  408.                 raise EOFError
  409.  
  410.             if len(s) == 0:
  411.                 raise EOFError
  412.             
  413.             self.buffer += s
  414.             self._stage0()
  415.         
  416.         return self._stage1()
  417.  
  418.     
  419.     def _stage0(self):
  420.         if self.bufstate == 0 and len(self.buffer) >= 4:
  421.             s = self.buffer[:4]
  422.             self.buffer = self.buffer[4:]
  423.             self.bufneed = struct.unpack('<i', s)[0]
  424.             self.bufstate = 1
  425.         
  426.  
  427.     
  428.     def _stage1(self):
  429.         if self.bufstate == 1 and len(self.buffer) >= self.bufneed:
  430.             packet = self.buffer[:self.bufneed]
  431.             self.buffer = self.buffer[self.bufneed:]
  432.             self.bufneed = 4
  433.             self.bufstate = 0
  434.             return packet
  435.         
  436.  
  437.     
  438.     def pollmessage(self, wait):
  439.         packet = self.pollpacket(wait)
  440.         if packet is None:
  441.             return None
  442.         
  443.         
  444.         try:
  445.             message = pickle.loads(packet)
  446.         except pickle.UnpicklingError:
  447.             print >>sys.__stderr__, '-----------------------'
  448.             print >>sys.__stderr__, 'cannot unpickle packet:', repr(packet)
  449.             traceback.print_stack(file = sys.__stderr__)
  450.             print >>sys.__stderr__, '-----------------------'
  451.             raise 
  452.  
  453.         return message
  454.  
  455.     
  456.     def pollresponse(self, myseq, wait):
  457.         """Handle messages received on the socket.
  458.  
  459.         Some messages received may be asynchronous 'call' or 'queue' requests,
  460.         and some may be responses for other threads.
  461.  
  462.         'call' requests are passed to self.localcall() with the expectation of
  463.         immediate execution, during which time the socket is not serviced.
  464.  
  465.         'queue' requests are used for tasks (which may block or hang) to be
  466.         processed in a different thread.  These requests are fed into
  467.         request_queue by self.localcall().  Responses to queued requests are
  468.         taken from response_queue and sent across the link with the associated
  469.         sequence numbers.  Messages in the queues are (sequence_number,
  470.         request/response) tuples and code using this module removing messages
  471.         from the request_queue is responsible for returning the correct
  472.         sequence number in the response_queue.
  473.  
  474.         pollresponse() will loop until a response message with the myseq
  475.         sequence number is received, and will save other responses in
  476.         self.responses and notify the owning thread.
  477.  
  478.         """
  479.         while None:
  480.             
  481.             try:
  482.                 qmsg = response_queue.get(0)
  483.             except Queue.Empty:
  484.                 pass
  485.  
  486.             (seq, response) = qmsg
  487.             message = (seq, ('OK', response))
  488.             
  489.             try:
  490.                 message = self.pollmessage(wait)
  491.                 if message is None:
  492.                     return None
  493.             except EOFError:
  494.                 self.handle_EOF()
  495.                 return None
  496.             except AttributeError:
  497.                 return None
  498.  
  499.             (seq, resq) = message
  500.             how = resq[0]
  501.             self.debug('pollresponse:%d:myseq:%s' % (seq, myseq))
  502.             if how in ('CALL', 'QUEUE'):
  503.                 self.debug('pollresponse:%d:localcall:call:' % seq)
  504.                 response = self.localcall(seq, resq)
  505.                 self.debug('pollresponse:%d:localcall:response:%s' % (seq, response))
  506.                 if how == 'CALL':
  507.                     self.putmessage((seq, response))
  508.                     continue
  509.                 if how == 'QUEUE':
  510.                     continue
  511.                 continue
  512.                 continue
  513.             if seq == myseq:
  514.                 return resq
  515.                 continue
  516.             cv = self.cvars.get(seq, None)
  517.             if cv is not None:
  518.                 cv.acquire()
  519.                 self.responses[seq] = resq
  520.                 cv.notify()
  521.                 cv.release()
  522.                 continue
  523.             continue
  524.             continue
  525.             return None
  526.  
  527.     
  528.     def handle_EOF(self):
  529.         '''action taken upon link being closed by peer'''
  530.         self.EOFhook()
  531.         self.debug('handle_EOF')
  532.         for key in self.cvars:
  533.             cv = self.cvars[key]
  534.             cv.acquire()
  535.             self.responses[key] = ('EOF', None)
  536.             cv.notify()
  537.             cv.release()
  538.         
  539.         self.exithook()
  540.  
  541.     
  542.     def EOFhook(self):
  543.         '''Classes using rpc client/server can override to augment EOF action'''
  544.         pass
  545.  
  546.  
  547.  
  548. class RemoteObject(object):
  549.     pass
  550.  
  551.  
  552. def remoteref(obj):
  553.     oid = id(obj)
  554.     objecttable[oid] = obj
  555.     return RemoteProxy(oid)
  556.  
  557.  
  558. class RemoteProxy(object):
  559.     
  560.     def __init__(self, oid):
  561.         self.oid = oid
  562.  
  563.  
  564.  
  565. class RPCHandler(SocketServer.BaseRequestHandler, SocketIO):
  566.     debugging = False
  567.     location = '#S'
  568.     
  569.     def __init__(self, sock, addr, svr):
  570.         svr.current_handler = self
  571.         SocketIO.__init__(self, sock)
  572.         SocketServer.BaseRequestHandler.__init__(self, sock, addr, svr)
  573.  
  574.     
  575.     def handle(self):
  576.         '''handle() method required by SocketServer'''
  577.         self.mainloop()
  578.  
  579.     
  580.     def get_remote_proxy(self, oid):
  581.         return RPCProxy(self, oid)
  582.  
  583.  
  584.  
  585. class RPCClient(SocketIO):
  586.     debugging = False
  587.     location = '#C'
  588.     nextseq = 1
  589.     
  590.     def __init__(self, address, family = socket.AF_INET, type = socket.SOCK_STREAM):
  591.         self.listening_sock = socket.socket(family, type)
  592.         self.listening_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
  593.         self.listening_sock.bind(address)
  594.         self.listening_sock.listen(1)
  595.  
  596.     
  597.     def accept(self):
  598.         (working_sock, address) = self.listening_sock.accept()
  599.         if self.debugging:
  600.             print >>sys.__stderr__, '****** Connection request from ', address
  601.         
  602.         if address[0] == LOCALHOST:
  603.             SocketIO.__init__(self, working_sock)
  604.         else:
  605.             print >>sys.__stderr__, '** Invalid host: ', address
  606.             raise socket.error
  607.  
  608.     
  609.     def get_remote_proxy(self, oid):
  610.         return RPCProxy(self, oid)
  611.  
  612.  
  613.  
  614. class RPCProxy(object):
  615.     __methods = None
  616.     __attributes = None
  617.     
  618.     def __init__(self, sockio, oid):
  619.         self.sockio = sockio
  620.         self.oid = oid
  621.  
  622.     
  623.     def __getattr__(self, name):
  624.         if self._RPCProxy__methods is None:
  625.             self._RPCProxy__getmethods()
  626.         
  627.         if self._RPCProxy__methods.get(name):
  628.             return MethodProxy(self.sockio, self.oid, name)
  629.         
  630.         if self._RPCProxy__attributes is None:
  631.             self._RPCProxy__getattributes()
  632.         
  633.         if self._RPCProxy__attributes.has_key(name):
  634.             value = self.sockio.remotecall(self.oid, '__getattribute__', (name,), { })
  635.             return value
  636.         else:
  637.             raise AttributeError, name
  638.  
  639.     
  640.     def __getattributes(self):
  641.         self._RPCProxy__attributes = self.sockio.remotecall(self.oid, '__attributes__', (), { })
  642.  
  643.     
  644.     def __getmethods(self):
  645.         self._RPCProxy__methods = self.sockio.remotecall(self.oid, '__methods__', (), { })
  646.  
  647.  
  648.  
  649. def _getmethods(obj, methods):
  650.     for name in dir(obj):
  651.         attr = getattr(obj, name)
  652.         if callable(attr):
  653.             methods[name] = 1
  654.             continue
  655.     
  656.     if type(obj) == types.InstanceType:
  657.         _getmethods(obj.__class__, methods)
  658.     
  659.     if type(obj) == types.ClassType:
  660.         for super in obj.__bases__:
  661.             _getmethods(super, methods)
  662.         
  663.     
  664.  
  665.  
  666. def _getattributes(obj, attributes):
  667.     for name in dir(obj):
  668.         attr = getattr(obj, name)
  669.         if not callable(attr):
  670.             attributes[name] = 1
  671.             continue
  672.     
  673.  
  674.  
  675. class MethodProxy(object):
  676.     
  677.     def __init__(self, sockio, oid, name):
  678.         self.sockio = sockio
  679.         self.oid = oid
  680.         self.name = name
  681.  
  682.     
  683.     def __call__(self, *args, **kwargs):
  684.         value = self.sockio.remotecall(self.oid, self.name, args, kwargs)
  685.         return value
  686.  
  687.  
  688.